1. Technical Field of the Invention
In general, the present invention relates to a modulation apparatus and a modulation method, a demodulation apparatus and a demodulation method as well as a program presenting medium. More particularly, the present invention relates to a preferable modulation apparatus and a preferable modulation method, a preferable demodulation apparatus and a preferable demodulation method as well as a preferable program presenting medium used in operations to record data onto a recording medium at a high recording density and playback data recorded in a recording medium at a high recording density.
2. Prior Art
When data is transmitted through a transmission line or recorded onto a recording medium such as a magnetic disc, an optical disc or a magneto-optic disc, the data is modulated into code matching the transmission line or the recording medium prior to the transmission or recording. As a technique of modulation, block encoding is known. In the block encoding, a data string is blocked into units each comprising mxc3x97i bits. Each of the units which is referred to hereafter as a data word is then converted into a code word comprising nxc3x97i bits in conformity with a proper coding rule. For i=1, this code word is a fixed length code. In the case of i having a plurality of values each selected from the range 1 to imax, a maximum of i, the resulting code word is a variable length code. In general, a code resulting from the block encoding is expressed as a variable length code (d, k; m, n; r).
Here, i is called a constraint length and r is imax, a maximum constraint length. d is the minimum number of 0s appearing between two consecutive 1s. d is referred to as a minimum run of 0s. On the other hand, k is the maximum number of 0s appearing between two consecutive 1s. k is referred to as a maximum run of 0s.
By the way, in an operation to record variable length code obtained from the block encoding described above onto a recording medium such as an optical disc or a magneto-optic disc, for example, on to a compact disc (CD) or a minidisc (MD), the variable length code undergoes an NRZI (Non Return to Zero Inverted) modulation wherein each xe2x80x9c1xe2x80x9d of the variable length code is interpreted as inversion while a xe2x80x9c0xe2x80x9d is interpreted as non-inversion The variable length code completing the NRZI modulation is then recorded. The variable length code completing the NRZI modulation is referred to as a recording wave train. In the case of a magneto-optic disc conforming to the early ISO specifications prescribing a not so large recording density, a train of bits completing recording modulation are recorded as they are without undergoing the NRZI modulation.
Let notations Tmin and Tmax denote the minimum and maximum inversion periods of a recording wave train respectively. In this case, in order to record the recording wave train at a high recording density in the linear speed direction, a long minimum inversion period Tmin or a large minimum run d is preferred. In addition, from the clock generation point of view, it is desirable to have a short maximum inversion period Tmax or a small maximum run k. In order to satisfy these requirements, a variety of modulation techniques have been proposed.
To put it concretely, for an optical disc, a magnetic disc or a magneto-optic disc, there are proposed or actually used modulation techniques for generating a variable length code RLL (1-7) which is also expressed as (1, 7; m, n; r) and a variable length code RLL (2-7) also expressed as (2, 7 m, n; r) as well as a fixed length code RLL (1-7) also expressed as (1, 7; m, n; 1) used in an ISO specification MO. As for a disc apparatus currently under research and development such as an optical disc and a magneto-optic disc having a high recording density, an RLL code (Run length Limited Code) with a minimum run d of 1 is commonly used.
The following is an example of a conversion table of the variable length RLL (1 7) code.
The symbol x used in the conversion table has the value xe2x80x9c1xe2x80x9d for a next following channel bit of xe2x80x9c0xe2x80x9d or has the value xe2x80x9c00xe2x80x9d for a next following channel bit of xe2x80x9c1xe2x80x9d. The maximum constraint length r is 2.
Parameters of the variable length code RLL (1-7) are (1, 7; 2, 3; 2). The minimum inversion period Tmin which can be expressed by (d+1) T is thus equal to 2 (=1+1) T where T is a bit gap in the recording wave train. The minimum inversion period Tmin which can be expressed also by (m/n)xc3x972 Tdata is thus equal to 1.33 (=2/3xc3x972) Tdata where Tdata is a bit gap in the data string. The maximum inversion period Tmax which can be expressed by (k+1) T is thus equal to (7+1) T=8T=8xc3x97(m/n) Tdata=8xc3x972/3 Tdata=5.33 Tdata. The detection window width Tw which can be expressed also by (m/n) Tdata is thus equal to 0.67 (=2/3) Tdata.
By the way, in a train of channel bits completing the RLL (1-7). modulation shown in Table 1, a generation frequency corresponding to a period of 2T which is equal to the minimum inversion period Tmin is most observed to be followed by generation frequencies corresponding to periods of 3T and 4T. The fact that a lot of edge information is generated at short intervals such as 2T and 3T is advantageous to the generation of a clock signal in many cases.
As the recording line density is further increased, however, the minimum run this time adversely becomes a problem. That is, if minimum runs 2T are generated consecutively, the recording wave train is prone to distortion generated therein. This is because a 2T wave output is smaller than other wave outputs and, hence, easily affected by factors such as a defocus and a tangential tilt. In addition, at a high line density, recording of consecutive minimum marks (2T) is also easily affected by disturbances such as noise. Thus, an operation to play back the data will also be prone to errors. In this case, a pattern of errors in reproduction of the data is observed as shifts of the front and rear edges of a minimum mark in many cases. As a result, the length of the generated bit error increases.
As described above, when data is transmitted through a transmission line or recorded onto a recording medium, the data is modulated into code matching the transmission line or the recording medium prior to the transmission or recording. If the code resulting from the modulation contains a direct current component, a variety of error signals such as tracking errors generated in control of a servo of the disc drive become prone to variations or jitters are generated easily. For this reason, it is thus desirable to make as many efforts to prevent the modulated code from containing a direct current component as possible.
In order to prevent the modulated code from containing a direct current component, control of a DSV (Digital Sum Value) to prevent the modulated code from containing a direct current component has been proposed. The DSV is a total found by adding up the values of a train of bits (symbols of data), wherein the values +1 and xe2x88x921 are assigned to xe2x80x9c1xe2x80x9d and xe2x80x9c0xe2x80x9d in the train respectively, which results from NRZI modulation (that is, level encoding) of a train of channel bits. The DSV is an indicator of a direct current component contained in a train of codes. Decreasing the absolute value of the DSV through DSV control is equivalent to suppressing the magnitude of a direct current component contained in a train of codes.
DSV control is not applied to a modulation code generated in accordance with the variable length RLL (1-7) table shown as Table 1 given above. DSV control for such a case is accomplished by calculating a DSV of a train of encoded bits (a train of channel bits) after the modulation for a predetermined period of time and inserting a predetermined number of DSV control bits into the train of encoded bits (the train of channel bits).
At any rate, the DSV control bits are basically redundant bits. If the efficiency of the code conversion is to be taken into consideration, it is thus desirable to reduce the number of DSV control bits to a smallest possible value.
In addition, if DSV control bits are inserted, it is also desirable to make the minimum run d and the maximum run k unchanged. This is because a change in (d, k) will have an effect on recording/playback characteristics.
As described above, in an operation to record RLL code at a high line density or an operation to play back RLL code recorded at a high line density, there is raised a problem that a pattern of consecutive minimum runs d will cause a long error to be generated easily.
In addition, in the case of RLL code such as the RLL (1-7) code, DSV control necessitates insertion of DSV control bits into an arbitrary part of a string of code words (a train of channel bits). Since the DSV control bits are basically redundant bits, however, it is desirable to reduce the number of inserted DSV control bits to a smallest possible value. In order to keep the minimum run and the maximum run at constant values, however, the number of DSV control bits is at least 2. It is thus desirable to reduce the number of DSV control bits to an even smaller value.
The present invention addresses the problems described above. It is an object of the present invention to allow DSV control to be executed for producing high efficiency control bits on RLL code of (d, k; m, n) where the minimum run d 1, that is RLL code of (1, 7; 2, 3) so that the number of consecutive minimum runs is reduced while the minimum run and the maximum run are being kept.
It is another object of the present invention to prevent propagation of a demodulation error from escalating by using a conversion table having a simplest possible configuration.
A modulation apparatus may be characterized by having conversion means for converting input data into code in accordance with a conversion table wherein said conversion table enforces a conversion rule, according to which the remainder of division of a xe2x80x981xe2x80x99 count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of a xe2x80x981xe2x80x99 count of an element in the string of code words resulting from conversion of said data string by 2 and conversion codes of said conversion table comprise:
basic codes for d=1, k=7, m=2 and n=3 where d is a minimum run and k is a run length limit;
first substitution codes for limiting the number of consecutive appearances of said minimum run d; and
second substitution codes for keeping said run length limit k.
A modulation method may be characterized by including a conversion step of converting input data into code in accordance with a conversion table wherein said conversion table enforces a conversion rule, according to which the remainder of division of a xe2x80x981xe2x80x99 count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of a xe2x80x981xe2x80x99 count of an element in the string of code words resulting from conversion of said data string by 2 and conversion codes of said conversion table comprise:
basic codes for d=1, k=7, m=2 and n=3 where d is a minimum run and k is a run length limit;
first substitution codes for limiting the number of consecutive appearances of said minimum run d; and
second substitution codes for keeping said run length limit k.
A program presenting medium for presenting a program implementing processing including a conversion step of converting input data into code in accordance with a conversion table data in a modulation apparatus for converting data with a basic data length of m bits into variable length code (d, k; m, n; r) with a basic code length of n bits is characterized in that said conversion table enforces a conversion rule, according to which the remainder of division of a xe2x80x981xe2x80x99 count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of a xe2x80x981xe2x80x99 count of an element in the string of code words resulting from conversion of said data string by 2 and conversion codes of said conversion table comprise:
basic codes for d=1, k=7, m=2 and n=3 where d is a minimum run and k is a run length limit;
first substitution codes for limiting the number of consecutive appearances of said minimum run d; and
second substitution codes for keeping said run length limit k.
A demodulation apparatus may be characterized by having conversion means for converting input code into data in accordance with a conversion table wherein said conversion table enforces a conversion rule, according to which the remainder of division of a xe2x80x981xe2x80x99 count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of a xe2x80x981xe2x80x99 count of an element in the string of code words resulting from conversion of said data string by 2 and conversion codes of said conversion table comprise:
basic codes for d=1, k=7, m=2 and n=3 where d is a minimum run and k is a run length limit;
first substitution codes for limiting the number of consecutive appearances of said minimum run d; and
second substitution codes for keeping said run length limit k.
A demodulation method may be characterized by having a conversion step of converting input code into data in accordance with a conversion table wherein said conversion table enforces a conversion rule, according to which the remainder of division of a xe2x80x981xe2x80x99 count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of a xe2x80x981xe2x80x99 count of an element in the string of code words resulting from conversion of said data string by 2 and conversion codes of said conversion table comprise:
basic codes for d=1, k=7, m=2 and n=3 where d is a minimum run and k is a run length limit;
first substitution codes for limiting the number of consecutive appearances of said minimum run d; and
second substitution codes for keeping said run length limit k.
A program presenting medium for presenting a program including a conversion step of converting input code into data in accordance with a conversion table in a demodulation apparatus for converting variable length code (d, k; m, n; r) with a basic code length of n bits into data with a basic data length of m bits may be characterized in that said conversion table enforces a conversion rule, according to which the remainder of division of a xe2x80x981xe2x80x99 count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of a xe2x80x981xe2x80x99 count of an element in the string of code words resulting from conversion of said data string by 2 and conversion codes of said conversion table comprise:
basic codes for d=1, k=7, m=2 and n=3 where d is a minimum run and k is a run length limit;
first substitution codes for limiting the number of consecutive appearances of said minimum run d; and
second substitution codes for keeping said run length limit k.
Conversion processing be may be carried out on the basis of a conversion table enforcing a conversion rule, according to which the remainder of division of a xe2x80x981xe2x80x99 count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of a xe2x80x981xe2x80x99 count of an element in the string of code words resulting from conversion of the data string by 2 and conversion codes of the conversion table comprising:
basic codes for d=1, k=7, m=2 and n=3;
first substitution codes for limiting the number of consecutive appearances of the minimum run d; and
second substitution codes for keeping the run length limit.
Before starting the explanation of some preferred embodiments of the present invention, in order to clarify relations associating means of the present invention described in the claims with implementations adopted in the embodiments, in the following description characterizing the invention, each of the means is followed by a typical implementation enclosed in parentheses in the form xe2x80x9ca means (implemented for example by a typical implementation)xe2x80x9d. It is needless to say, however, that the typical implementation is not intended to be construed in a limiting sense. That is, a means is not necessarily limited to a typical implementation associated with the means.
A modulation apparatus may be characterized by having conversion means (implemented for example by a modulation unit shown in FIG. 12) for converting input data into code in accordance with a conversion table (implemented for example by Table 2) wherein said conversion table enforces a conversion rule, according to which the remainder of division of a xe2x80x981xe2x80x99 count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of a xe2x80x981xe2x80x99 count of an element in the string of code words resulting from conversion of said data string by 2 and conversion codes of said conversion table comprise:
basic codes for d=1, k=7, m=2 and n=3 where d is a minimum run and k is a run length limit;
first substitution codes for limiting the number of consecutive appearances of said minimum run d; and
second substitution codes for keeping said run length limit k.
The modulation apparatus may be further characterized by further having a synchronization signal inserting means (implemented for example by a synchronization signal inserting unit 212 shown in FIG. 9) for inserting a synchronization signal including a unique pattern not included in said conversion codes of said conversion table into any arbitrary position in said string of code words. The modulation apparatus may be further characterized by further having DSV control means (implemented f or example by a DSV control bit determining/inserting unit 11 shown in FIG. 1) for controlling DSVs of input data and supplying said DSVs to said conversion means. The modulation apparatus may be further characterized in that said conversion means comprises:
a first code detecting means (implemented for example by a minimum run consecutive appearance limiting code detecting unit 33 shown in FIG. 3) for detecting said first substitution codes for limiting the number of consecutive appearances of said minimum run d; and
a second code detecting means (implemented for example by a maximum run assuring code detecting means 34 shown in FIG. 3) for detecting said second substitution codes for keeping run length limit.
A demodulation apparatus may be characterized by having conversion means (implemented for example by a demodulation unit 111 shown in FIG. 5) for converting input code into data in accordance with a conversion table wherein said conversion table (implemented for example by Table 2) enforces a conversion rule, according to which the remainder of division of a xe2x80x981xe2x80x99 count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of a xe2x80x981xe2x80x99 count of an element in the string of code words resulting from conversion of said data string by 2 and conversion codes of said conversion table comprise:
basic codes for d=1, k=7, m=2 and n=3 where d is a minimum run and k is a run length limit;
first substitution codes for limiting the number of consecutive appearances of said minimum run d; and
second substitution codes for keeping said run length limit k.
A demodulation apparatus may be further characterized by further having a bit removing means (implemented for example by a DSV control bit removing unit 112 shown in FIG. 5) for removing redundant bits inserted at predetermined intervals into said code.
Preferred embodiments of the present invention are described as follows. In order to make the explanation easy to understand, in the following description, an array of bits xe2x80x980xe2x80x99 andxe2x80x981xe2x80x99 of data prior to conversion, that is, a pre-conversion data string, is represented as a train of bits enclosed in parentheses ( ) like for example (000011). On the other hand, an array of bits xe2x80x980xe2x80x99 and xe2x80x981xe2x80x99 of a code resulting from the conversion, that is, a string of post-conversion string words is represented as a train of bits delimited by a pair of symbols xe2x80x9clike for example xe2x80x9c000100100xe2x80x9d. Tables 2 and 3 given below are examples of a conversion table for converting data into a code in accordance with the present invention.
When next channel bits are xe2x80x98010xe2x80x99 convert xe2x80x9811 01 11xe2x80x99 into xe2x80x98001 000 000xe2x80x99 after using the main table and the termination table.
As shown in Table 2, the conversion table shows codes resulting from conversion including basic codes, substitution codes and termination codes. Conversion processing can not be carried out without a basic code. In the conversion table, the basic codes are the codes resulting from conversion of the data strings (11) to (000000). Conversion processing can be performed even if a substitution code does not exist. If a substitution code exists, however, more effective conversion processing can be carried out. In the conversions table, the substitution codes are the codes resulting from conversion of the data strings (110111), (00001000) and (00000000). The termination code is used for terminating code resulting from conversion at any arbitrary position. The termination codes in the table are the codes resulting from conversion of the data strings (00) and (0000). In addition, the conversion table also prescribes synchronization signals.
In Table 2, the minimum run d is 1 whereas the maximum run k is 7. One of the elements of the basic codes include an indeterminate code, that is, a code indicated by the asterisk symbol xe2x80x98*xe2x80x99. The bit represented by the symbol xe2x80x98*xe2x80x99 of the indeterminate code can be determined to be either xe2x80x9c0xe2x80x9d or xe2x80x9c1xe2x80x9d, in order to keep the values of the minimum run d and the maximum run k without regard to an immediately preceding or succeeding string of code words. To put it in detail, if the 2-bit data string to be converted is (11), a code resulting from the conversion can be xe2x80x9c000xe2x80x9d or xe2x80x9c101xe2x80x9d in dependence on the immediately preceding string of code words. To be more specific, if the single channel bit of the immediately preceding string of code words is xe2x80x9c1xe2x80x9d, the 2-bit data string (11) is converted into the code xe2x80x9c000xe2x80x9d in order to keep the minimum run d. If the single channel bit of the immediately preceding string of code words is xe2x80x980xe2x80x9d, on the other hand, the 2-bit data string (11) is converted into the code xe2x80x9c101xe2x80x9d in order to keep the maximum run k.
The basic codes shown in the conversion table of Table 2 have a variable length structure. The number of basic codes with a constraint length i of 1 is 3, a value which is smaller than a required number of 4 (=2{circumflex over ( )}m=2{circumflex over ( )}2) These 3 basic codes are xe2x80x9c*0*xe2x80x9d, xe2x80x9c001xe2x80x9d and xe2x80x9c010xe2x80x9d. As a result, in an operation to convert a data string, there is encountered a data string which can not be converted with only a constraint length i of 1. For this reason, it is necessary to refer to basic codes with a constraint length i of up to 3 in the Table 2 in an operation to convert all data strings. That is, basic codes with a constraint length i of up to 3 is included in the Table 2 so as to allow Table 2 to serve as a sufficient conversion table.
In addition, the conversion table of Table 2 also includes substitution codes for limiting consecutive appearances of the minimum run d. If the data string is (110111) and a string of code words following a code resulting from the conversion of the data string is xe2x80x9c010xe2x80x9d, the data string is converted into a code word of xe2x80x9c010 000 000xe2x80x9d. If the string of codewords following a code resulting from the conversion of the data string is other than xe2x80x9c010xe2x80x9d, on the other hand, the data string (110111) is converted in 2-bit units. To put in detail, the 2-bit trains (11), (01) and (11) in the data string are converted into a string of code words xe2x80x9c*0* 010 and *0*xe2x80x9d. As a result, the consecutive appearances of the minimum run d in the string of code words resulting from the conversion of the data string can be restrained, limiting the number of repeated minimum runs to a maximum of 6.
Furthermore, the conversion table of Table 2 enforces a conversion rule, according to which the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of the 1,111 count of an element in the string of code words resulting from conversion of the data string by 2. That is, if the xe2x80x9c1xe2x80x9d count of an element in the data string is even, the xe2x80x9c1xe2x80x9d count of an element in the string of code words is also even and, if the xe2x80x9c1xe2x80x9d count of an element in the data string is odd, on the other hand, the xe2x80x9c1xe2x80x9d count of an element in the string of code words is also odd. For example, a data string of (000001) is converted into a string of code words of xe2x80x9c010 100 000xe2x80x9d. In this case, the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the data string by 2 is 1 which is equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2. That is, the xe2x80x9c1xe2x80x9d counts of the data string and the string of code words are both odd. As another example, a data string of (000000) is converted into a string of code words of xe2x80x9c010 100 100xe2x80x9d. In this case, the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the data string by 2 is 0 which is equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2. That is, the xe2x80x9c1xe2x80x9d counts of the data string and the string of code words are both even.
In addition, the maximum constraint length r in the conversion table of Table 2 is 4. Codes in the table with a constraint length i of 4 are the substitution codes for implementing the value 7 of the maximum run k. Such a substitution code is referred to as a maximum run assuring code. That is, a data string of (00001000) is converted into a string of code words of xe2x80x9c000 100 100 100xe2x80x9d whereas a data string of (00000000) is converted into a string of code words of xe2x80x9c010 100 100 100xe2x80x9d. It should be noted, that in this case, the value of the minimum run d is kept at 1 as well.
If the conversion table of Table 2 does not include substitution codes which have a constraint length i of 4, the maximum constraint length r for the table is 3, causing code with a maximum run k of 8 to be generated. Since the table include basic codes with a constraint length i of 4, however, code with a maximum run k of 7 can be generated.
In general, the greater the maximum run k, the more inconvenient the generation of a clock signal and, thus, the poorer the stability of the system. Thus, by reducing the value of the maximum run k from 8 to 7, the characteristic of the system can be improved commensurately with the reduction in maximum run k.
That is, if the conversion table of Table 2 is created to include basic codes only, the maximum constraint length r for such a table is 3. In this case, it is possible to generate code that has a minimum run d of 1 and a maximum run k of 8. In addition, the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2.
If the conversion table is created to also include substitution codes for limiting consecutive appearances of the minimum run d in addition to the basic codes, the maximum constraint length r for such a table is also 3. In this case, however, it is possible to generate code that has a minimum run d of 1 and a maximum run k of 8 whereas the number of consecutive minimum runs d is limited to a upper limit value. In addition, the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2.
If the conversion table is created to also include substitution codes for assuring a maximum run k of 7 in addition to the substitution codes for limiting consecutive appearances of the minimum run d and the basic codes, the maximum constraint length r for such a table is 4. In this case, it is possible to generate code that has a minimum run d of 1 and a maximum run k of 7 whereas the number of consecutive minimum runs d is limited to a upper limit value. In addition, the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2.
In general, however, the greater the maximum constraint length r, the poorer the propagation characteristic of a demodulation error generated in the event of a bit shift, that is, an error which is generated because an edge bit is shifted in the forward or backward direction from its normal position by 1 bit.
Comparison of Table 1 with Table 2 shows that the maximum constraint length r of the former is 2 while that of the latter is 4. Thus, Table 2 should result in characteristics poorer than Table 1. However, results of simulation to be described later by referring to Table 7 indicate that the characteristics of Table 2 are not so poor in comparison with Table 1. For example, as shown in Table 7, the average byte error rate of Table 1 is 1.014 bytes while that of Table 2 is 1.67 bytes, a value which is not much greater than that of Table 1. The difference in average byte error rate can be considered to be attributed to the fact that the number of conversion code groups in Table 1 is smaller than that in Table 2 by a difference of 2.
By the way, for a case in which a synchronization signal is inserted into any arbitrary position in a string of code words (that is, a train of channel bits) generated as a result of conversion carried out in accordance with a conversion table of Table 2, the conversion table produces code with a variable length structure. This is because the conversion table includes a termination table prescribing termination codes for terminating code resulting from conversion at any arbitrary position. A termination code is used whenever necessary.
Assume, for example, that a synchronization signal is inserted into a particular position in the code resulting from conversion. In this case, first of all, at a point of junction between a string of code words immediately preceding the particular position and a string of code words immediately succeeding the particular position, junction bits are set while keeping the minimum run d and the maximum run k and a unique pattern representing the synchronization signal is set between the junction bits. Consider a pattern of the synchronization signal that breaks the value 7 of the maximum run k. In this case, the pattern of a synchronization signal with a minimum length is a 12-bit code word (that is, 12 channel bits) given as follows:
xe2x80x9c#01 000 000 001xe2x80x9d
The symbol xe2x80x9c#xe2x80x9d at the head of the pattern of the synchronization signal is a junction bit which can be xe2x80x980xe2x80x99 or xe2x80x9c1xe2x80x9d to be described later. The second channel bit following the xe2x80x9c#xe2x80x9d bit is xe2x80x9c0xe2x80x9d for keeping the minimum run d. The third channel bit and the subsequent bits are set at values which form a 9T unique pattern, a code pattern not prescribed in Table 2, to give a maximum run k of 8. As shown in the above pattern, the third channel bit and the last channel bit sandwich 8 consecutive xe2x80x9c0xe2x80x9d bits. It should be noted that, even though the last channel bit in the pattern of the synchronization signal is set at xe2x80x9c1xe2x80x9d, by using the conversion table of Table 2, the minimum run d can be kept.
Next, the termination table and the junction bit xe2x80x9c#xe2x80x9d in the bit pattern of the synchronization signal are explained. As shown in Table 2, the termination table is constructed as follows:
The termination table is required for basic codes with a constraint length i that provides a number of pairs each comprising a data string and a string of code words smaller than the required number 4 (=2{circumflex over ( )}m=2{circumflex over ( )}2).
To put it in detail, in the case of Table 2, for the constraint length i=1, since the number of pairs each comprising a data string and a string of code words is 3, the termination table is required. For the constraint length i=2, since the number of pairs each comprising a data string and a string of code words is also 3, the termination table is required. For the constraint length i=3, the number of pairs each comprising a data string and a string of code words is 5 including a pair having a substitution code. The rest is 4 pairs each including a basic code. Since the required number 4 is met, the termination table is not needed. For the constraint length i=4, since the strings of code words are all substitution codes, it is not necessary to take a termination code into consideration. Thus, the termination table is required for the constraint length i=1 wherein a termination code is used for a data string of (00). By the same token, the termination table is required for the constraint length i=2 wherein a termination code is used for a data string of (0000). According to the termination table, the data strings (00) and (0000) are converted into strings of code words xe2x80x9c000xe2x80x9d and xe2x80x9c010100xe2x80x9d respectively. As a result, in an operation to insert a synchronization signal, it is possible to avoid a situation in which data preceding the pattern of the synchronization signal can no longer be converted. That is, the conversion system is capable of eliminating a situation in which it is no longer possible to let the code immediately preceding the synchronization signal serve as a termination.
The bit xe2x80x9c#xe2x80x9d of the pattern of the synchronization signal is used to distinguish a case of using the termination table from a case in which the termination table is not used. To be more specific, the first channel bit xe2x80x9c#xe2x80x9d at the head of the pattern of the synchronization signal is set at xe2x80x981xe2x80x99 to indicate that a termination code is used or set at xe2x80x980xe2x80x99 to indicate that no termination code is used. By doing so, it is possible to correctly determine whether or not the termination table is used, that is, whether or not the termination code is used.
As described above, the pattern of a synchronization signal with a minimum length is a 12-bit code word (that is, 12 channel bits). Since a pattern of the synchronization signal that breaks the value 7 of the maximum run k but provides a maximum run k of 8 (9T) is acceptable, any other synchronization signal pattern forming a code word of at least 12 bits can be constructed. In the case of formation of a 15-bit code word, for example, the following can be made:
In the case of a 21-bit code word, the following synchronization signal can be made:
xe2x80x9c#01 000 000 001 000 000 001xe2x80x9d
The above 21-bit synchronization signal includes 2 consecutive patterns which each provide a maximum run k 8 (9T). Such a synchronization signal can be detected with a higher degree of reliability. Then, in the case of formation of a 24-bit code word, the following synchronization signal can be made:
xe2x80x9c#01 001 000 000 001 000 000 001xe2x80x9d
The above synchronization signal, a pattern having the form of xe2x80x9c3T-9T-9Txe2x80x9d, reduces the probability that a large run (T) appears before and/or after the two consecutive patterns each providing a maximum run k of 8 (9T) as well as increases the detection power. It is possible to select what detection power that a synchronization signal should provide in accordance with system requirements.
Table 3 is another typical conversion table provided by the present invention.
The conversion table of Table 3 has a structure wherein, for the minimum run d=1, the maximum run k=7 and the constraint length i=1, 4 (=2{circumflex over ( )}m=2{circumflex over ( )}2) basic codes provided. That is, for the constraint length i=1, the 4 basic codes are put in a main table. For the constraint length i=2 or greater, tables of substitution codes are provided for limiting parameters such as the minimum run d and the maximum run k. To be more specific, Table A for the constraint length i=2 prescribes substitute codes for limiting the minimum run d to 1. Table B for the constraint length i=3 prescribes substitute codes for limiting the maximum run k to an upper limit of 8. Table C for the constraint length i=4 prescribes substitute codes for limiting consecutive appearances of the minimum run d having the value 1. Table D for the constraint length i=4 prescribes substitute codes for limiting the maximum run k to an upper limit of 7. Thus, in the conversion table of Table 3, the maximum constraint limit r=4.
As described above, the conversion table of Table 3 includes substitution codes for limiting consecutive appearances of the minimum run d. For example, a data string of (0001001) is converted into a string of code words of xe2x80x9c100 010 010 010xe2x80x9d. As for a data string of (10010001), an immediately preceding code word is referenced to determine whether the immediately preceding channel bit is xe2x80x9c0xe2x80x9d or xe2x80x9c1xe2x80x9d. If the immediately preceding channel bit is xe2x80x9c011, the data string is converted into a string of code words of xe2x80x9c100 000 010 010xe2x80x9d. If the immediately preceding channel bit is xe2x80x9c1xe2x80x9d, on the other hand, the data string is converted into a string of code words of xe2x80x9c000 010 010 010xe2x80x9d. As a result, the string of code words resulting from the data conversion has a number of consecutively repeated minimum runs limited to a maximum of 6.
In addition, the conversion table of Table 3 enforces a conversion rule, according to which the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2. That is, if the xe2x80x9c1xe2x80x9d count of an element in the data string is even, the xe2x80x9c1xe2x80x9d count of an element in the string of code words is also even and, if the xe2x80x9c1xe2x80x9d count of an element in the data string is odd, on the other hand, the xe2x80x9c1xe2x80x9d count of an element in the string of code words is also odd. For example, a data string of (1000) is converted into a string of code words of xe2x80x9c000 010xe2x80x9d. In this case, the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the data string by 2 is 1 which is equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2. That is, the xe2x80x9c1xe2x80x9d counts of the data string and the string of code words are both odd. As another example, a data string of (111111) is converted into a string of code words of xe2x80x9c000 010 010xe2x80x9d. In this case, the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the data string by 2 is 0 which is equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2. That is, the xe2x80x9c1xe2x80x9d counts of the data string and the string of code words are both even.
In addition, codes in the conversion table of Table 3 with a constraint length i of 4 equal to the maximum constraint length r are the substitution codes for implementing the value 7 of the maximum run k. In the case of conversion using such a substitution code, an immediately preceding string of code words is referenced. To be more specific, if the immediately preceding string of code words is xe2x80x9c010xe2x80x9d, conversion is implemented. If the data string is (11100000) and the immediately preceding string of code words is xe2x80x9c010xe2x80x9d, for example, conversion is implemented to result in a string of code words of xe2x80x9c000 001 010 010xe2x80x9d.
As another example, if the data string is (11100010) and the immediately preceding string of code words is xe2x80x9c010xe2x80x9d, the data string is converted into a string of code words of xe2x80x9c100 001 010 010xe2x80x9d.
The conversion table of Table 3 given above can not be built from basic codes only in order to implement RLL encoding. RLL code with an assured minimum run d and an assured maximum run k can be produced by using basic codes in the main table as well as substitution codes in Table A for a constraint length i of 2 and Table B for a constraint length i of 3. In this case, the maximum constraint length r is 3 and it is possible to generate code that has a minimum run d of 1 and a maximum run k of 8. In addition, the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2.
If Table C prescribing substitution codes for limiting consecutive appearances of the minimum run d is included in the configuration of the conversion table of Table 3 in addition to the main table and Tables A and B, the maximum constraint length r is 4 and it is possible to generate code that has a minimum run d of 1, a maximum run k of 8 and a limited number of consecutive appearances of minimum runs d. In addition, the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2. It should be noted, that in this case, it is not always necessary to refer to the immediately preceding string of code words as is the case of using Table C of Table 3.
If Table D prescribing substitution codes for assuring a maximum run k of 7 is included in the configuration of Table 3 in addition to the main table and Tables A and B and Table C prescribing substitution codes for limiting consecutive appearances of the minimum run d, the maximum constraint length r is 4 and it is possible to generate code that has a minimum run d of 1, a maximum run k of 7 and a limited number of consecutive appearances minimum runs d. In addition, the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2.
The termination table of Table 2 is not required in processing to insert a synchronization signal into a particular position in a string of code words (or a train of channel bits) resulting from conversion using the conversion table of Table 3. This is because, according to the conversion table of Table 3, code can be terminated at a constraint length i of 1.
In order to make insertion of a pattern of a synchronization signal result in as efficient code as possible, the pattern is determined as follows. The 3-bit code word immediately preceding a unique pattern (or a code word string) serving as a synchronization signal and the 3-bit code word immediately succeeding the unique pattern are code words resulting from conversion according to Table 3. The 3 bits of the code words immediately preceding and immediately succeeding the unique pattern each have a format in which data bits and junction bits are mixed as follows.
First of all, the 3 bits of the immediately preceding code word are determined as follows. An m-bit unit of a data word prior to conversion where m=2 is examined. The first bit of the 2-bit unit at the head of the data word prior to conversion is an information bit while the second bit has a value of xe2x80x981xe2x80x99 f or indicating a synchronization signal. The 2-bit unit at the head of the data word is converted into a code word (channel bits) in accordance with Table 3. To put it concretely, the m bits (2 bits) of the data word (x1) are converted into n bits (3 bits) of a code word xe2x80x9cxx0xe2x80x9d.
Then, the 3 bits of the immediately succeeding code word are determined as follows. By the same token, an m-bit unit of a data word prior to conversion where m=2 is examined. In this case, however, the first bit of the 2-bit unit at the head of the data word prior to conversion has a value of xe2x80x980xe2x80x99 for indicating a synchronization signal while the second bit is an information bit. The 2-bit unit at the head of the data word is converted into a code word (channel bits) in accordance with Table 3. To put it concretely, the m bits (2 bits) of the data word (0x) are converted into n bits (3 bits) of a code word xe2x80x9c10xxe2x80x9d.
When a unique pattern of the synchronization signal is set as a pattern breaking the value 7 of the maximum run k, a synchronization signal pattern that can be implemented with a shortest possible length includes the unique pattern code word of at least 12 bits (12 channel bits) given as follows:
xe2x80x9cxx0 100 000 000 10xxe2x80x9d
where the value of xe2x80x9cxxe2x80x9d is dependent on the conversion table. The above 15-bit code word includes 3 xe2x80x9cxxe2x80x9d bits. 2 xe2x80x9cxxe2x80x9d bits are at the head of the code word while 1 xe2x80x9cxxe2x80x9d bit is at the tail thereof. The 3 xe2x80x9cxxe2x80x9d bits represent the 2-bit unit of a data word prior to conversion. The remaining 12 channel bits of the code word are a redundant portion actually representing the pattern of the synchronization signal. The third channel bit of the code word is set at xe2x80x9c0xe2x80x9d in order to keep the minimum run d. As for the rest starting with the fourth channel bit, 9T is set as a synchronization signal pattern to provide a maximum run k of 8. To put it in detail, 8 xe2x80x9c0xe2x80x9ds are arranged consecutively between xe2x80x9c1xe2x80x9d and xe2x80x9c1xe2x80x9d.
As described above, the unique pattern of a synchronization signal with a minimum length is a 12-bit code word (that is, 12 channel bits). Since a pattern of the synchronization signal that breaks the value 7 of the maximum run k but provides a maximum run k of 8 (9T) is acceptable, any other synchronization signal pattern forming a unique pattern code word of at least 12 bits can be constructed. In the case of formation of a 15-bit unique pattern code word, for example, the following synchronization signal can be made:
xe2x80x9cxx0 100 000 000 100 10xxe2x80x9d
In the case of formation of a 21-bit code word, the following synchronization signal can be made:
xe2x80x9cXxxo 100 000 000 100 000 000 1oxxe2x80x9d
The above 21-bit synchronization signal comprises 2 consecutive patterns which each provide a maximum run k of 8 (9T). According to a synchronization signal, the detection power can be increased. It is possible to select what detection power that a synchronization signal should provide in accordance with system requirements.
Much like the conventional method, after a data string is converted by using a conversion table like the one shown as Table 2 or 3, DSV control can be executed by adding DSV control bits at predetermined intervals to a train of channel bits resulting from the conversion. By making use of the relation between the data string and the string of code words resulting from conversion based on Table 2 and 3, however, the DSV control can be executed with an even higher degree of efficiency.
To put it in detail, the conversion rule is followed so that the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in a data string by 2 having a value of 0 or 1 shall always be equal to the remainder of division of the xe2x80x9c1xe2x80x9d count of an element in the string of code words resulting from conversion of the data string by 2. Thus insertion of DSV control bits having a value of xe2x80x9c1xe2x80x9d to indicate inversion and a value of xe2x80x9c0xe2x80x9d to indicate non-inversion into a train of channel bits is equivalent to insertion of DSV control bits having a value of xe2x80x9c1xe2x80x9d to indicate inversion and a value of xe2x80x9c0xe2x80x9d to indicate non-inversion into a train of data bits.
Consider, for example, a case in which 3 bits (001) of data are converted in accordance with Table 2. Let a DSV control bit x following the 3 bits be sandwiched in the data. In this case, the data including the DSV control bit becomes (001-x) where x is the 1-bit control bit having the value xe2x80x980xe2x80x99 or xe2x80x981xe2x80x99. For x=0, the data including the DSV control bit is converted in accordance with Table 2 as follows:
For x=1, on the other hand, the data including the DSV control bit is converted in accordance with Table 2 as follows:
By applying level encoding through NRZI modulation to the string of code words resulting from the conversion using Table 2, the following level encoded code string are obtained:
As shown in the above table, the last 3 bits of the first encoded code string are inverted bits of the last 3 bits of the second encoded code string. The results above imply that, by selecting (1) or (0) as a value of the DSV control bit, DSV control can be executed within a data string.
Next, consider redundancy introduced by the DSV control. Execution of the DSV control by insertion of 1 DSV control bit into a data string corresponds to execution of the DSV control by insertion of 1.5 DSV control bits into a train of channel bits where the value 1.5 is the reciprocal of the conversion rate m/n=2/3 of Tables 2 and 3. In order to execute DSV control for an RLL (1-7) table like the one shown in Table 1, it is necessary to apply the control in a train of channel bits. In this case, at least 2 channel bits are required to keep the minimum run d, making the relative redundancy high in comparison with the DSV control applied to a data string for Tables 2 and 3. In other words, in the present system, by executing DSV control in a data string, the efficiency of the DSV control can be improved.